{ "cells": [ { "cell_type": "markdown", "id": "fa37ce86", "metadata": {}, "source": [ " \n", "\n", "# Quantum Operations and Simulations in Qiskit\n", "\n", " " ] }, { "cell_type": "markdown", "id": "bbe310ff", "metadata": {}, "source": [ "\n", "## Contents\n", "\n", "1. [Introduction](#introduction)\n", "\n", " 1.1 [Overview of Qiskit](#qiskit_overview)\n", " \n", " 1.2 [The quantum bit](#quantum_bit)\n", " \n", " \n", "2. [Single-qubit states](#single_states)\n", "\n", " 2.1 [Single-qubit operations](#single_operations)\n", " \n", "\n", "3. [Multi-qubit states](#multi_qubits)\n", "\n", " 3.1 [Multi-qubit operations](#multi_op)\n", " \n", " \n", "4. [Summary](#summary)" ] }, { "cell_type": "markdown", "id": "8cb64fe2", "metadata": {}, "source": [ " \n", "\n", "# 1. Introduction\n", "\n", "\n", "This set of classes draws ideas from an abundance of online learning materials for Qiskit, particularly the [Qiskit online tutorials](https://github.com/Qiskit/qiskit-iqx-tutorials) and [textbook](https://qiskit.org/textbook/preface.html). Another source was Miguel Ramalho's [Teach me quantum](https://github.com/msramalho/Teach-Me-Quantum), which was [recognized](https://www.ibm.com/blogs/research/2019/01/ibmq-teach-quantum-winners/) by IBM.\n", "\n", "Images that are not our own were adapted from the IBM Q experience documentation and public Qiskit materials." ] }, { "cell_type": "markdown", "id": "53c8d8ab", "metadata": {}, "source": [ " \n", "\n", "## 1.1. QISKit - an overview\n", "\n", "\"Note: Trusted Notebook\" width=\"400 px\" align=\"center\">\n", "\n", "Qiskit is an open-source framework for working with quantum computers at the level of algorithms, quantum circuits, or even pulses. It can be installed and executed locally, but to execute your code in actual, public access quantum processors, you need to create a [IBM Quantum experience](https://quantum-computing.ibm.com) account.\n", "\n", "\n", "Its main goals are:\n", "\n", " - to build a software stack for the development of quantum software and applications;\n", " - to make it easier for students to understand and learn about quantum computation;\n", " - to facilitate research on the most important open issues facing quantum computation today.\n", "\n", "Qiskit supports the *Python* language, which is itself compatible with multiple programming paradigms.\n", "\n", "\n", "The main pillar of this toolkit (which the majority of these classes will feature) is **Qiskit Terra**, and it allows us to:\n", "\n", "- compose quantum programs at the level of circuits and pulses;\n", "- optimize them for the constraints of a particular device;\n", "- interact with the execution backends.\n", "\n", " \n", "
\n", " \"Qiskit\n", " Qiskit and its elements (Source)\n", "
\n", " \n", "\n", "\n", "\n", "As of version `0.12`, Qiskit is composed of other 3 main modules:\n", "\n", "**Aer** is a simulator framework for the stack - it allows us to:\n", "- simulate the execution of a quantum circuit under ideal (ie noiseless) conditions;\n", "- obtain the complete mathematical description of a given quantum state or quantum operator;\n", "- construct highly configurable models for realistic noisy simulations of the errors that occur during execution on real devices;\n", "\n", "
\n", "Note that these simulations are performed on classical computers, and so are limited by classical resources.\n", "
\n", "\n", "**Ignis** is a framework for understanding and mitigating noise in quantum circuits and systems. The experiments provided in Ignis are grouped into the topics of:\n", "- characterization of quantum system parameters such as noise (T1 and T2), and control errors in the gates;\n", "- verification of quantum operation and ciruit performance, using for example process tomography or randomized benchmarking;\n", "- error mitigation routines generated by execution of calibration circuits;\n", "\n", "**Aqua** provides higher-level functionality by use of a library of quantum algorithms upon which applications of near term quantum computing can be built. Aqua specifically identifies four domains that stand to benefit from the development of quantum computation:\n", "- Chemistry;\n", "- Artificial Intelligence (AI);\n", "- Optimization;\n", "- Finance.\n", "\n", "*Qiskit >=0.25.0 deprecates the Qiskit Aqua project.* The application modules that are provided by qiskit-aqua have been split into several new packages: qiskit-optimization, qiskit-nature, qiskit-machine-learning, and qiskit-finance. \n", "\n", "In March 2021, Qiskit launched **[Qiskit Metal](https://qiskit.org/metal/)** the first open-ource project to design superconducting quantum devices.\n", "\n", "Qiskit is still under an intense development cycle, which means that new updates and features are added several times a year. You can find more information abou Qiskit elements in [here](https://qiskit.org/documentation/stable/0.24/the_elements.html)." ] }, { "cell_type": "markdown", "id": "345962fb", "metadata": {}, "source": [ " \n", "\n", "## 1.2. The quantum bit\n", "\n", " \n", "\n", "### A physical qubit\n", "\n", "Any quantum system with two orthogonal states can be used to represent a quantum bit, or *qubit* for short.\n", "\n", "\n", "\n", "Consider a simplified representation of the electron of a Hydrogen atom, orbiting around the nucleus, with two possible energy states. As this is a quantum particle, these energy states are quantized, that is, they take only discrete values. The energy state of the electron can be considered a quantum bit.\n", "\n", "How can we represent quantum states and associated operations?" ] }, { "cell_type": "markdown", "id": "ff2266ef", "metadata": {}, "source": [ " \n", "\n", "### Bra-ket notation\n", "\n", "In quantum mechanics, wave functions and other quantum states can be represented as vectors in an abstract vector space.\n", "\n", "The bra–ket notation is a standard notation for describing quantum states. It uses angle brackets (the $\\rangle$ and $\\langle$ symbols) with a vertical bar (the $|$ symbol) to denote labelled vectors.\n", "\n", "- A *ket* $|u\\rangle$ is typically written as a column vector, while a *bra* $\\langle v |$ is typically written as a row vector.\n", "\n", "- A *bra* and a *ket* with the same label are [Hermitian conjugates](https://en.wikipedia.org/wiki/Conjugate_transpose) of each other. \n", "\n", "This notation simplifies the representation of the scalar product of vectors, as well as the action of a linear operator on a vector and other operations over a complex vector space.\n", "\n", "
\n", " \n", "**Example 1.1 - Inner product with bra-ket**\n", "\n", "Consider the ket vector $|u\\rangle$ and $|v\\rangle$ on a two-dimensional space:\n", "\n", "$$\n", "|u\\rangle = \n", "\\begin{pmatrix}\n", "1 \\\\\n", "0\n", "\\end{pmatrix};\n", "\\;\\;\n", "|v\\rangle = \n", "\\begin{pmatrix}\n", "0 \\\\\n", "i\n", "\\end{pmatrix};\n", "$$\n", "\n", " \n", "\n", "Their respective hermitian conjugates, $\\langle u|$ and $\\langle v|$, can be represented as row vectors:\n", "\n", " \n", "\n", "$$\n", "\\langle u| = \n", "\\begin{pmatrix}\n", "1 & 0\n", "\\end{pmatrix};\n", "\\;\\;\n", "\\langle v | = \n", "\\begin{pmatrix}\n", "0 & -i\n", "\\end{pmatrix};\n", "$$\n", "\n", " \n", "\n", "The inner product between $\\langle v|$ and $|u\\rangle$ is represented as $\\langle v | u \\rangle$:\n", "\n", " \n", "\n", "$$\n", "\\langle v | u \\rangle =\n", "\\begin{pmatrix}\n", "0 & -i\n", "\\end{pmatrix}\n", "\\begin{pmatrix}\n", "1 \\\\\n", "0\n", "\\end{pmatrix} = 0 \\, ;\n", "$$\n", "\n", " \n", "\n", "A null inner product means that these vectors are orthogonal, thereby forming a basis in a two-dimensional space.\n", "
" ] }, { "cell_type": "markdown", "id": "2ba40eee", "metadata": {}, "source": [ " \n", "\n", "# 2. Single qubit states\n", "\n", " \n", "\n", "A single qubit quantum state $|\\psi\\rangle$ can be written as a complex superposition of its basis states, which by convention are generally named $|0\\rangle$ and $|1\\rangle$.\n", "\n", "$$|\\psi\\rangle = \\alpha|0\\rangle + \\beta |1\\rangle$$\n", "\n", "Here, $\\alpha$ and $\\beta$ are probability amplitudes generally described by complex numbers. When the qubit is measured, the quantum system \"collapses\" to the state $|0\\rangle$ with probability $|\\alpha|^2$, or to the state $|1\\rangle$ with probability $|\\beta|^2$.\n", "\n", "\n", "The basis states represent the quantum analogue to the classical bit states $0$ and $1$:\n", "\n", "$$\n", "|0\\rangle = \n", "\\begin{pmatrix}\n", "1 \\\\\n", "0\n", "\\end{pmatrix};\n", "\\;\\;\\;\n", "|1\\rangle = \n", "\\begin{pmatrix}\n", "0 \\\\\n", "1\n", "\\end{pmatrix};\n", "$$\n", "\n", "Which allows for the column representation of $|\\psi\\rangle$:\n", "\n", "$$\n", "|\\psi\\rangle = \n", "\\begin{pmatrix}\n", "\\alpha \\\\\n", "\\beta\n", "\\end{pmatrix}\n", "$$\n", "\n", "where $|\\alpha|^2 + |\\beta^2| = 1$." ] }, { "cell_type": "markdown", "id": "4e411fc9", "metadata": {}, "source": [ "
\n", "\n", "**Exercise 1.1 - Orthogonality**\n", "\n", "Another well known example of a basis in a two-dimensional space is formed by the $|+\\rangle$ and $|-\\rangle$ states:\n", "\n", " \n", "\n", "$$\n", "|+\\rangle = \\frac{1}{\\sqrt{2}}\n", "\\begin{pmatrix}\n", "1 \\\\\n", "1\n", "\\end{pmatrix};\n", "\\;\\;\\;\n", "|-\\rangle = \\frac{1}{\\sqrt{2}}\n", "\\begin{pmatrix}\n", "1 \\\\\n", "-1\n", "\\end{pmatrix};\n", "$$\n", "\n", " \n", "\n", "- Verify that these states are orthogonal by calculating the inner product $\\langle + | - \\rangle$.\n", "\n", "
" ] }, { "cell_type": "markdown", "id": "ee6051ec", "metadata": {}, "source": [ " \n", "\n", "### Bloch sphere\n", "\n", "The absolute squares of the probability amplitudes, $|\\alpha|^2$ and $|\\beta|^2$, represent the probability of the corresponding measurement outcome. A basic rule for probability is that the probabilities of all possible outcomes must add up to $1$, so it follows that $\\alpha$ and $\\beta$ must be constrained by the equation:\n", "\n", "$$|\\alpha|^2+ |\\beta|^2 = 1$$\n", "\n", "Ignoring the global phase of a qubit, i.e.\n", "\n", "$$|\\psi\\rangle := e^{i\\delta} |\\psi\\rangle$$\n", "\n", "only two real numbers are required to describe a single qubit quantum state. A convenient representation is\n", "\n", "$$|\\psi\\rangle = \\cos(\\theta/2)|0\\rangle + \\sin(\\theta/2)e^{i\\phi}|1\\rangle$$\n", "\n", "where $0\\leq \\phi < 2\\pi$, and $0\\leq \\theta \\leq \\pi$. \n", "\n", "It is then possible to create a one-to-one correspondence between a qubit state ($\\mathbb{C}^2$) and the points on the surface of a unit sphere ($\\mathbb{R}^3$). This is called the Bloch sphere representation of a qubit state.\n", "\n", "\"\"\n", "\n", "By contrast, a representation of a classical bit over the Bloch sphere would only require the two points of the sphere intersecting the Z axis." ] }, { "cell_type": "markdown", "id": "9036f3ce", "metadata": {}, "source": [ " \n", "\n", "## 2.1 Single-Qubit Gates\n", "\n", " \n", "\n", "Quantum gates/operations are usually represented as matrices. A gate acting on a single qubit is represented by a $2\\times 2$ unitary matrix $U$ with complex entries. The action of the quantum gate on the qubit is determined by multiplying the matrix representing the gate with the vector which represents the quantum state.\n", "\n", "$$|\\psi'\\rangle = U|\\psi\\rangle$$\n", "\n", "Some of the single-qubit gates available are:\n", "- Measurement gates\n", "- Pauli gates\n", "- Hadamard gate\n", "- Generalized unitary gates (with constraints)\n" ] }, { "cell_type": "markdown", "id": "66b2cc09", "metadata": {}, "source": [ "
\n", "\n", "**Importing Qiskit**\n", "\n", " \n", "\n", "The following sections will make use of Qiskit to design and visualize circuits and quantum operations. \n", "\n", "**The execution of the code cells in this notebook requires that the relevant Qiskit modules be imported first.**\n", " \n", "To execute a code block, select a code cell and press `SHIFT + ENTER`. Consecutive cells can be executed by repeating this command.\n", "\n", "If the below cells output an error, it probably means Qiskit hasn't been installed properly. Refer to [this webpage](https://qiskit.org/documentation/install.html) for installation details.\n", "
" ] }, { "cell_type": "code", "execution_count": 3, "id": "df15e7c4", "metadata": { "ExecuteTime": { "end_time": "2018-09-29T00:04:16.313210Z", "start_time": "2018-09-29T00:04:14.460647Z" }, "hideOutput": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Modules successfully imported.\n" ] } ], "source": [ "# Comments on code cells are preceded by '#'\n", "\n", "# Relevant QISKit modules\n", "\n", "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, BasicAer, execute\n", "\n", "from qiskit.tools.visualization import plot_histogram, visualize_transition\n", "\n", "# Useful additional packages \n", "\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "import numpy as np\n", "from math import pi\n", "\n", "# Output a message to confirm all modules are imported\n", "\n", "print(\"Modules successfully imported.\")" ] }, { "cell_type": "markdown", "id": "0a6e2b8c", "metadata": {}, "source": [ " \n", "\n", "### Measurement gate\n", "\n", "A direct measurement causes the system to collapse to a deterministic state i.e. stabilise in a non-reversible way. Physically, we still don't know exactly how this collapse occurs, in what is called the [measurement problem](https://en.wikipedia.org/wiki/Measurement_problem).\n", "\n", "A repeated measurement of the collapsed quantum system will return the same results, just like repeated readings of a bit string.\n", "\n", "When we perform a measurement on a qubit, we observe either $|0\\rangle$ or $|1\\rangle$ - which is then interpreted as a binary digit, $0$ or $1$. As such, a single measurement of a quantum system yields at most 1 bit per qubit. When a quantum system is in a superposition of basis states, many more measurements are needed to accurately estimate probability amplitudes.\n", "\n", "\n", "\n", "In Qiskit measurement operations can be performed by defining the correspondence between the measured qubit and the bit where the result of the operation (0 or 1) is going to be stored. \n", "\n", "Since the measuring process physically collapses the qubit into a classical state, QISKit does not allow for subsequent quantum operations on the measured qubit.\n", "\n", "
\n", " \n", "**Building your first quantum circuit!**\n", "\n", " \n", "\n", "In Qiskit, before building a quantum circuit, we first neet to define a `QuantumRegister(n)` object, with `n` being the desired number of qubits. \n", "\n", "To perform measurements, a `ClassicalRegister(m)` is also required, where `m` is the number of bits to contain the results of the measurement. \n", "\n", "Lastly, a `QuantumCircuit` object needs to be defined, containing a list of quantum and classical registers. Quantum operations may then be called on this object.\n", "\n", " \n", "\n", "The measurement operation `measure(qr[i], cr[j])` is called on a circuit object by specifying the quantum register `qr`and qubit `i` to be measured, and the classical register `cr` and bit `j` which is to store the measurement value. A measurement can also be called over the complete register, provided that registers `qr` and `cr` are the same size: `measure(qr, cr)`.\n", "\n", " \n", "\n", "A complete circuit can be visualized graphically by calling the `draw` method.\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": 4, "id": "1aea98e1", "metadata": {}, "outputs": [], "source": [ "# Create quantum register with 2 qubits\n", "#n=\n", "#qr = \n", "\n", "# Create a classical register with 2 bits\n", "#m=\n", "#cr = \n", "\n", "# Quantum circuit\n", "#qc_ground = \n", "\n", "#Measurement operation\n", "\n", "# Draw circuit (using matplotlib)\n" ] }, { "cell_type": "markdown", "id": "3e554b68", "metadata": {}, "source": [ "### Pauli gates\n", "\n", "#### Gate $X$: bit-flip gate \n", "\n", "The X-gate is also known as NOT gate or “bit-flip”, since it changes a state $| 0 \\rangle $ to $| 1 \\rangle $ and vice versa. **This is the quantum analogue to a classical NOT gate.**\n", "\n", "On the Bloch sphere representation, this operation corresponds to a rotation of the state around the X-axis by $\\pi$ radians.\n", "\n", "
\n", " \n", " (Source)\n", "
\n", "\n", "\n", "\n", "The $X$ gate can be represented by a $2 \\times 2$ matrix:\n", "$$\n", "X = \n", "\\begin{pmatrix}\n", "0 & 1\\\\\n", "1 & 0\n", "\\end{pmatrix}\n", "$$\n", "\n", "\n", "#### $Y$: bit-and-phase-flip gate\n", "\n", "The $Y$ gate is defined by the matrix:\n", "\n", "$$\n", "Y = \n", "\\begin{pmatrix}\n", "0 & -i\\\\\n", "i & 0\n", "\\end{pmatrix}\n", "$$\n", "\n", "It is equivalent to a rotation around Y-axis of the Bloch sphere by $\\pi$ radians.\n", "This gate maps $| 0 \\rangle $ to $i | 1 \\rangle $, and $| 1 \\rangle$ to $ - i | 0 \\rangle$\n", "\n", "#### $Z$: phase-flip gate\n", "\n", "The phase flip gate $Z$ is defined by:\n", "\n", "$$\n", "Z = \n", "\\begin{pmatrix}\n", "1 & 0\\\\\n", "0 & -1\n", "\\end{pmatrix}\n", "$$\n", "\n", "It leaves the basis state $|0 \\rangle $ unchanged, while mapping $| 1 \\rangle$ to $- | 1 \\rangle $." ] }, { "cell_type": "code", "execution_count": 5, "id": "48d3ec97", "metadata": { "scrolled": true }, "outputs": [], "source": [ "# Create registers\n", "#qr = \n", "\n", "# Quantum circuit\n", "#qc_pauli =\n", "\n", "# Perform X gate on qubit 0\n", "\n", "# Perform Y gate on qubit 1\n", "\n", "# Perform Z gate on qubit 2\n", "\n", "# Draw circuit\n" ] }, { "cell_type": "markdown", "id": "ac11384b", "metadata": {}, "source": [ "### Hadamard gate\n", "\n", "The Hadamard gate may be used to create superposition. It maps the basis state $| 0 \\rangle$ to $| + \\rangle =\\frac{| 0 \\rangle + | 1 \\rangle }{\\sqrt{2}}$, and $| 1 \\rangle $ to $ | - \\rangle =\\frac{ |0 \\rangle - |1 \\rangle }{\\sqrt{2}}$. On the Bloch sphere, $| + \\rangle$ and $| - \\rangle $ are represented by points on the X axis. \n", "\n", "When measured, these states have equal probability of becoming $| 1\\rangle $ or $| 0 \\rangle $, since the square modulus of the probability amplitude for each of the basis states has equal value.\n", "\n", "
\n", " \n", " (Source)\n", "
\n", "\n", "In fact, $|+\\rangle $ and $| - \\rangle $ are indistinguishable when measured on the computational basis. However, the states can be identified by measuring the qubit on the superposition basis, i.e. along the X-axis. A way to achieve this is by simply applying an Hadamard gate before performing the measurement.\n", "\n", "The Hadamard gate is defined by:\n", "\n", "$$\n", "H = \\frac{1}{\\sqrt{2}}\n", "\\begin{pmatrix}\n", "1 & 1\\\\\n", "1 & -1\n", "\\end{pmatrix}\n", "$$\n", "\n", " \n", "\n", "**Note**: The Hadamard gate, along with the X, Y and Z gates, is self-inverse: $H.H = I$." ] }, { "cell_type": "code", "execution_count": 6, "id": "065af640", "metadata": {}, "outputs": [], "source": [ "#qr = \n", "\n", "# Quantum circuit\n", "#q_hadamard = \n", "\n", "# Perform the operation\n", "\n", "# Draw the circuit\n" ] }, { "cell_type": "markdown", "id": "a570f7f3", "metadata": {}, "source": [ "
\n", "\n", "**Exercise 1.2 - Gates and basis**\n", "\n", " \n", "\n", "- Simulate the circuits `qc_a`, `qc_b` and `qc_c`, below, and examine the results.\n", "\n", " \n", "\n", "**Note**: in Qiskit (and by convention), every qubit is initialized in the state $|0\\rangle$.\n", "
" ] }, { "cell_type": "code", "execution_count": 7, "id": "838b86ac", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# qc_a\n", "\n", "# Create registers\n", "qr = QuantumRegister(1, 'qc_a')\n", "cr = ClassicalRegister(1, 'c_a')\n", "\n", "# Create circuit\n", "qc_a = QuantumCircuit(qr, cr)\n", "\n", "# Perform quantum operations\n", "qc_a.h(qr[0])\n", "\n", "# Measure\n", "qc_a.measure(qr[0], cr[0])\n", "\n", "# Draw\n", "qc_a.draw(output='mpl')" ] }, { "cell_type": "markdown", "id": "0cf5e774", "metadata": {}, "source": [ "
\n", " \n", " \n", "**Simulating a quantum circuit**\n", "\n", " \n", "\n", "The **Aer** component allows for the simulation of the execution and measurement of a quantum circuit, locally, for a small number of qubits, using the `qasm_simulator`.\n", "\n", " \n", "\n", "For that, we need to call the simulator using the `BasicAer.get_backend` method. We then define a _job_, i.e. the task assigned to a specific backend - simulator or real quantum processor - by calling the function `execute(qc, backend, shots)`, where `qc` is the quantum circuit to be executed, `backend` is the execution backend, and `shots` is the number of executions to be performed.\n", "\n", " \n", "\n", "After the job is executed, we can extract a `result()`, which allows us to get the measurement result frequencies with `get_counts(qc)`, and, from that, plot an histogram of probabilities with the function `plot_histogram(counts)`.\n", "\n", "\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": 8, "id": "581038bb", "metadata": {}, "outputs": [], "source": [ "# Use Aer's 'qasm_simulator'\n", "#q_simulator = \n", "\n", "# Execute the circuit 1000 times on the qasm simulator\n", "#job_a = \n", "\n", "# Grab the results from the job\n", "#result_a = \n", "#counts_a = \n", "\n", "# Print frequencies, and plot histogram\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "b1f374f2", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOgAAAB7CAYAAAB+W8yVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAANY0lEQVR4nO3dfVBU5R4H8O/ZXRQYQDAmimXlohgTFGKQ15vIS5pXe5FcQOWKAaOjIWWavZpU3gvqzfeZRusmRVOKhmzWePkjytjUnEnWq/Eyilq2Aq4Icge7aQG79w+HrQWFXdhln12+n5kzA2fPeZ7fjvP1ec6zhz2SyWQygYiEJHN2AUR0ewwokcAYUCKBMaBEAmNAiQTGgBIJjAElEhgDSiQwBpRIYAwokcAYUCKBMaBEAmNAiQTGgBIJjAElEhgDSiQwBpRIYAwokcAYUCKBMaBEAmNAiQTGgBIJjAElEhgDSiQwBpRIYAwokcAUzi5gONBUAY1tQ9+vMgBQxw3s3FVn6nDq2jX7FmSlCb6+2BwROaBzV6xYgZMnT9q3ICvExMRg27Ztdm+XAR0CjW3A+WZnV2GbU9eu4Zu2q84uw2YnT56EVqt1dhl2wykukcAYUCKBMaBEAmNAiQTGgBIJjAElEtiwDWhTUxMkSUJJSYmzSyEX4+fnN2R9DdvPQXU6HQDgwQcfdHIl5Cx33XUXUlNTERcXh8jISHh5eeH69euora1FVVUVysrKcPnyZYtz7rzzThw6dAiHDh3C8uXLHV7jsA5oQEAAwsPDnV0KDbGwsDCsX78earUaHh4evV6fNGkScnJysHXrVpSVleHVV1/FTz/9ZA5nVFQUgJsjaXt7u0NrFWqKazQasWnTJowfPx6enp6YMGECtFotIiIisGTJEotjP//8c0yfPh3+/v7w9vbG/fffj/fff9/qvqqqqhAXF4c9e/YgJiYG3t7eiImJwZdffmnvt2Wz/QVJ+O5AgdX7RWCsrkHHbHXv7bEUdMx4FMbqGmeXCAB4+umnUV1djXnz5kGSJGg0GixbtgxTpkxBdHQ04uPjkZeXhwMHDkAulyMjIwPV1dVYuXKlOZy1tbVITk52eDgBwUbQRYsWQaPRID8/H7Gxsfj222+RkZGBK1eu4Pnnnzcfl5+fj8LCQmRlZWHZsmXw8vLCkSNHcPWq9bem6XQ6yGQyFBUVYe3atZAkCa+//jpSUlJw+vRpqFQqR7xFtyW7/z7IPtdY7DP99hu6Vr0E+PtDihrYvbX2VFhYiNWrVwMASkpK8OKLL6KxsbHXcUePHsWOHTugUqmwefNmpKenY8uWLQBgDueVK1eGpGZhAlpSUoLi4mJUVlYiMTERAJCcnIwTJ05Ao9HggQceAABoNBoUFBSguLgYWVlZ5vNnzZpldV9NTU0wGAyYOnUqvvjiC8jlcgBAeHg4oqKicPDgQeTm5trx3Q1PXZu3wvTbb1CsfhmSzLmTtdzcXKxevRodHR3IycnB7t27+z3n4sWLeOaZZ/DQQw9BqVQCAIqKioYsnIBAU9x169Zh5syZ5nB2Cw8Ph4eHB6KjowHcHD2Tk5MtwmmrqqoqAEBBQYE5nAAQGRkJhUKB5mYXu7NdQF0f74HpP6eg+PsbkLy8nFrLuHHjsGnTJgBAdna2VeEEfl8QUiqV5pF27dq1CA0NdVitPQkR0IaGBtTU1CA9Pb3Xa3q9HlFRURg5ciT0ej3q6uowf/78QfWn0+kQFBSEhIQEi/0tLS3o7OxESEiIVe1IkmTVptVW2lzjd58VYucSf4utqf6ITW1otZVW19hzq6y0veZuxm8Ow7ivFPI38yEFBdl8fmXlwOu+1V+ybNiwAd7e3ti9ezf27NljVQ1/XBCqra3FxIkTUVpaCl9fX6xfv77X8Vqt1qY6rSXEFLehoQHAzWXvP7p+/Tq0Wq15+trU1AQA5unGQOl0OgQHB/faX1JSAplMhhkzZgyqfXuYlPIaJj25xmLf/oIk5xRjA2N9Pbo2boF8xXLIIu91djlQKpV48skn0dHRgRdeeMGqc3qGs/uac9WqVVCr1UhNTUVQUFCvj2AcQYgRNDAwEABQX19vsf+tt97CpUuXEBsbCwDmUNXUDG5FUKfT4cKFC/j111/N+9ra2rBhwwZkZmZavUBkMpms2hITkwZV70AlJiZZXWPPLSnJ9ppNLS3oeuMfkKXOgWxa8oDrTkoaeN09L5HS0tKgUChw4MABGAyGfvu+XTiBm9ekBw8exIgRI6BWqy3OS0xMtKlOawkxgo4dOxbR0dFYt24dRo8eDaVSif3796O8vBwAzAEdM2YMkpOTUVhYCLlcjtjYWFy9ehUVFRVYsGABpk6d2m9fjY2NMBgMCAsLw4IFC7B06VK0tLSgoKAAvr6+2L59u0Pfq7sy3biBrjf+DinyXsiyFjq7HLO4uJtfKVFRUdHvsX2Fs1tFRQVSUlLM7TqaECOoTCZDaWkpoqKikJubi5ycHAQGBiIvLw9yudy8QAQAn3zyCTIzM/H2229j5syZePbZZ9Ha2orISOuW8bvvIPr000+hUCgwZ84cLF++HPHx8Thy5Aj8/f0d8RbdnunIUZjOnoPpu+PoTEnt9Xmo8auvnVJX900Fp06d6vM4a8IJwPx1Kt3tOpoQIygA3HPPPfj6a8t/xIULF5pvweoWGBiIHTt2DLif2bNnm6cYe/fuHXA7jpS2ptKm/SKQTZ8G2fRpzi6jl/feew9KpRI//vhjn8ft3Lmz33ACwPnz51FYWAi9Xu+IcnsRJqC3UlVVhcmTJzu7DHJhO3futOq4vLw8mEwm5Obm9vk5p8FgwJo1a277ur0JMcW9lZ9//hn19fXmGxSs1dnZ2edmywU6DR8GgwFpaWlDehOCNYQdQX18fNDV1WXTORcuXEBYWFifx3zwwQfIzs4eRGVEQ0fYgA5EcHAwjh8/3ucx/QWYSCRuFdARI0YM2fI30VAQ9hqUiBhQIqExoEQCY0CJBMaAEgnMrVZxRaUMcL1+J/j62q+QIew7JibG5nN+0F8CAIwdc7fFz47u1xqSibfW0DD3yj//BQDY8PISi59FwCkukcAYUCKBMaBEAmNAiQTGgBIJjAElEhgDSiQwBpRIYAwokcAYUCKBMaBEAmNAiQTGgBIJjAElEhgD6iDPPfccQkJCoFDwT27dWWVlJaKiohAeHo7Fixfb/F3O/WFAHSQ9Pd38JG9yT0ajEYsXL0ZpaSnOnTuH9vZ2fPzxx3btgwF1kPj4+F4PJCb3cvz4cQQHB5ufrLdo0SKUlZXZtQ8GlGiAGhoaLB72PGbMGFy8eNGuffACiYadq/9tx+4DX8LY49t+tn9Q1utnuUyGzDmPwN/Pp1c7Q/FtQRxBadgZ7e+HiLEqXGpuxaXmVvP+nj9fam7FveGhtwwnAKhUKosRU6/XIyQkxK61MqA0LE2bEgtlUGCfx6juvhNJf4m57etxcXFoaGhAXV0dAKCoqAhqtdqeZQ7PgBYXF0OSJNTU1Disj6VLlyIkJARdXV0ICQlBXl6ew/oi28nlMsx9PBkKhfyWr3t4KDDv8WTIZbePiFwux65du5CWloZx48bBx8cHCxcutGudvAZ1kHffffe2r5lMJkiSNITV0K0EBQZgZuIkHPzqWK/XHkuejMDRo/pt4+GHHzaPoI4wLEdQZ+ro7MTbH36K70//4OxSCMBDsfchPFRpsS9irAp/jrnXSRVZctmAVldXIzU1FYGBgfD09MT48ePx2muv2dRGc3Mz5s6dCz8/P4waNQpPPfUU2traHFTxTVXfn0Hj5RZ4e410aD9kHZkkIe3RRHiOHAEA8PYcidRZicLMcFwyoDqdDpMnT0ZtbS02btyI8vJyvPLKKzAYDDa1k5WVhaCgIOzfvx9vvvkmNBoNZs+eDaPR6JC6Ozo78fWxk/hTyF0YNybYIX2Q7fz9fJDyyBQAwJy/ToWfj7eTK/qdSz76ISkpCXV1dTh79ixGjer/OqGn4uJi5OTkIDMzEx999JF5/4cffojs7GyUl5dj1qxZ/bbT/ZgAIltZ+2gJlxtBf/nlFxw+fBgZGRkDCucfzZ8/3+L3efPmQZIkaLXaQbVLZC8ut4rb1tYGo9Folw+Ee94r6+npCT8/P7S2tt7mDEu2PGDn2IlafFZxFIvnP9ZrUYLodlwuoAEBAZDJZGhsbBx0Wz2vWW/cuIH29nbccccdVp0/kCnurr3/tvkccj9uO8X19vZGQkICSkpK0N7ePqi29u7da/H7vn37YDKZkJiYOKh2iezFJReJdDodEhISEBoaipdeegmhoaHQ6/U4fPgwdu3a1e/53YtEKpUKKSkpeOKJJ1BXV4c1a9Zg4sSJ0Gq1kPVxB4ktOjo7sfHdfRjt74ulf3tCmOV7cg0uN8UFgNjYWBw7dgz5+flYuXIlbty4AZVK1WvRpz/FxcV45513kJaWBkmSoFarsW3bNruFE7j5uWf7z//D3MeTGE6ymUuOoK7ki8NV0DdexqJ5jzKgZDMGdAgYjUa7jso0fLhVQE0mU79f2iSXyzmSkctwq//WtVotPDw8+tx4EwK5ErcaQa9du4YzZ870eUxERAR8fX2HqCKiwXGrgBK5G7ea4hK5GwaUSGAMKJHAGFAigTGgRAJjQIkExoASCYwBJRIYA0okMAaUSGAMKJHAGFAigTGgRAJjQIkExoASCYwBJRIYA0okMAaUSGAMKJHAGFAigTGgRAJjQIkExoASCYwBJRLY/wErcNIQWTxlrQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# qc_b\n", "\n", "qr = QuantumRegister(1, 'qc_b')\n", "cr = ClassicalRegister(1, 'c_b')\n", "\n", "qc_b = QuantumCircuit(qr, cr)\n", "\n", "qc_b.h(qr[0])\n", "qc_b.z(qr[0])\n", "\n", "qc_b.measure(qr[0], cr[0])\n", "\n", "qc_b.draw(output='mpl')" ] }, { "cell_type": "code", "execution_count": 10, "id": "e3a6488e", "metadata": {}, "outputs": [], "source": [ "# Execute simulation\n", "#job_b = \n", "\n", "# Grab the results from the job\n", "#counts_b = \n", "\n", "# Print frequencies, and plot histogram\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "8928cf2b", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# qc_c\n", "\n", "qr = QuantumRegister(1, 'qc_c')\n", "cr = ClassicalRegister(1, 'c_c')\n", "\n", "qc_c = QuantumCircuit(qr, cr)\n", "\n", "qc_c.h(qr[0])\n", "qc_c.z(qr[0])\n", "qc_c.h(qr[0])\n", "\n", "qc_c.measure(qr[0], cr[0])\n", "\n", "qc_c.draw(output='mpl')" ] }, { "cell_type": "code", "execution_count": 12, "id": "fdfbe8c0", "metadata": {}, "outputs": [], "source": [ "# Execute simulation\n", "#job_c = \n", "\n", "# Grab the results from the job\n", "#counts_c = \n", "\n", "# Print frequencies, and plot histogram\n" ] }, { "cell_type": "markdown", "id": "6b9333fe", "metadata": {}, "source": [ "
\n", "\n", "**Exercise 1.2 - Gates and basis** (continued)\n", "\n", " \n", "\n", "The below diagram is a useful shorthand for quantum states conversion using quantum gates. It also depicts how quantum operations are reversible. A qubit in any of the four states $|0\\rangle$, $|1\\rangle$, $|-\\rangle$, $|+\\rangle$ can be converted to any other performing simple one qubit gates.\n", "\n", " \n", "\n", "\"\" \n", "\n", " \n", "\n", "**Questions:**\n", "\n", "\n", "1. Compare the simulation results of `qc_a` and `qc_b`. Do similar measurement results imply the same quantum state is being measured?\n", "\n", "1. Observe the results of `qc_c` and the diagram above. \n", "\n", " 1. How could we reach the same final state using only one quantum operation?\n", " 1. Verify your answer to the previous question by calculating $H.Z.H$ (the corresponding matrices are defined above in this notebook).\n", "\n", "
\n", "\n", " " ] }, { "cell_type": "markdown", "id": "6e29d064", "metadata": {}, "source": [ "
\n", " \n", "**Statevector simulator**\n", "\n", " \n", "\n", "**Question 1** of Exercise 1.2 can be verified by using another of **Aer** simulators, the `statevector_simulator`. This simulator is able to determine the vector describing the state of a quantum circuit at a given point.\n", "\n", "To use it, we only need to define the the statevector simulator as our execution backend.\n", "\n", " \n", "\n", "**Note**: To get accurate results from the statevector simulator, no measurement operations can be applied to the circuit, since measurements collapse superposition states into deterministic ones.\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": 13, "id": "bc0884b2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Final state of qc_a:\n" ] } ], "source": [ "# First, let's determine the vector describing the final state of the circuit qc_a\n", "\n", "# Remove measurement operations from circuit\n", "\n", "#qc_a.remove_final_measurements()\n", "\n", "# Use Aer's 'statevector_simulator'\n", "#v_simulator = \n", "\n", "# Execute the circuit\n", "#job_a =\n", "\n", "# Get the resulting state vector\n", "#state_a = job_a.result().get_statevector(qc_a, decimals=3)\n", "\n", "# Print vector as a column\n", "print(\"Final state of qc_a:\")\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "a819eb8c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Final state of qc_b:\n" ] } ], "source": [ "# Now, let's determine the final state of the circuit qc_b\n", "\n", "\n", "# Execute the circuit\n", "#job_b = \n", "\n", "# Get the resulting state vector\n", "#state_b = \n", "\n", "# Print vector as a column\n", "print(\"Final state of qc_b:\")\n" ] }, { "cell_type": "markdown", "id": "5506abd3", "metadata": {}, "source": [ "From the state vector simulator results, we can determine the final states in bra-ket notation:\n", "\n", "$$ |qc_a\\rangle = \\frac{1}{\\sqrt{2}}\n", "\\begin{pmatrix}\n", "1 \\\\\n", "1\n", "\\end{pmatrix}\n", "= |+\\rangle\n", "$$\n", "\n", "$$ |qc_b\\rangle = \\frac{1}{\\sqrt{2}}\n", "\\begin{pmatrix}\n", "1 \\\\\n", "-1\n", "\\end{pmatrix}\n", "= |-\\rangle\n", "$$" ] }, { "cell_type": "markdown", "id": "ed628367", "metadata": {}, "source": [ "
\n", " \n", "**Unitary simulator**\n", "\n", " \n", "\n", "**Question 2** of Exercise 1.2 can be verified by using another of **Aer** simulators, the `unitary_simulator`. This simulator is able to determine the vector matrix describing the composition of operations in the quantum circuit - in this case, $H.Z.H$.\n", "\n", " \n", "\n", "**Note**: As with the `statevector_simulator` no measurement operations should be applied before a simulation.\n", "
" ] }, { "cell_type": "code", "execution_count": 15, "id": "37c7cc0a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Unitary matrix of qc_c:\n" ] } ], "source": [ "# Now, let's determine the matrix of H.Z.H in q_c\n", "\n", "\n", "# Use Aer's 'unitary_simulator'\n", "#u_simulator = \n", "\n", "# Execute the circuit\n", "#job_c = \n", "\n", "# Get the resulting state vector\n", "#state_c = job_c.result().get_unitary(qc_c, decimals=3)\n", "\n", "# Print vector as a column\n", "print(\"Unitary matrix of qc_c:\")\n" ] }, { "cell_type": "markdown", "id": "d299db3a", "metadata": {}, "source": [ "From the unitary simulator results, we can see that:\n", "\n", "$$ H.Z.H =\n", "\\begin{pmatrix}\n", "0 & 1\\\\\n", "1 & 0\n", "\\end{pmatrix} = X\n", "$$\n" ] }, { "cell_type": "code", "execution_count": 16, "id": "c1cdb2f2", "metadata": {}, "outputs": [ { "ename": "VisualizationError", "evalue": "'Gate measure is not supported'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mVisualizationError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# Draw transaction on the Bloch sphere\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mvisualize_transition\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mqc_c\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfpg\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m20\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mspg\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtrace\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;32m~\\anaconda3\\envs\\qiskit_update\\lib\\site-packages\\qiskit\\visualization\\transition_visualization.py\u001b[0m in \u001b[0;36mvisualize_transition\u001b[1;34m(circuit, trace, saveas, fpg, spg)\u001b[0m\n\u001b[0;32m 229\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mgate\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mcircuit\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_data\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 230\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mgate\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mimplemented_gates\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 231\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mVisualizationError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Gate {gate[0].name} is not supported\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 232\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mgate\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m \u001b[1;32min\u001b[0m \u001b[0msimple_gates\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 233\u001b[0m \u001b[0mlist_of_circuit_gates\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mgates\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mgate\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[1;31mVisualizationError\u001b[0m: 'Gate measure is not supported'" ] } ], "source": [ "# Draw transaction on the Bloch sphere\n", "visualize_transition(qc_c, fpg=20, spg=1, trace=True)" ] }, { "cell_type": "markdown", "id": "889ead58", "metadata": {}, "source": [ " \n", "\n", "# 3. Multi-qubit states\n", "\n", " \n", "\n", "Multiple quantum bits can be described with the ket notation. The tensor product is typically implicit; for a state composed of qubits $q_0$ and $q_1$:\n", "\n", " \n", "\n", "$$\n", "|q_1\\rangle \\otimes |q_0\\rangle = |q_1\\rangle |q_0\\rangle = |q_1 q_0\\rangle\n", "$$\n", "\n", " \n", "\n", "**Note**: The ordering convention adopted in Qiskit writes the first qubit of a circuit at the far-right of the ket, and adds each additional qubit on the left:\n", "\n", " \n", "\n", "$$ |q_n\\rangle \\otimes \\cdots \\otimes |q_1\\rangle \\otimes |q_0\\rangle $$\n", "\n", " \n", "\n", "Keep in mind that this ordering may be different than quantum circuits and algorithms described in scientific literature, and needs to be taken into account when analysing results of multi-qubit measurements, or the algebraic description of multi-qubit operations and states.\n", "\n", "
\n", "\n", "**Example 1.2 - Tensor product**\n", "\n", "Consider two non-entangled qubits of a quantum circuit, $q_a$ and $q_b$. Their joint-state description can be written in bra-ket notation, with the tensor product providing an algebraic description of the state.\n", "\n", " \n", "\n", "$$|q_a q_b\\rangle = |q_a\\rangle \\otimes |q_b\\rangle = \n", "\\begin{pmatrix}\n", "q_{a1} \\\\ \n", "q_{a2}\n", "\\end{pmatrix} \\otimes\n", "\\begin{pmatrix}\n", "q_{b1} \\\\ \n", "q_{b2}\n", "\\end{pmatrix} =\n", "\\begin{pmatrix}\n", "q_{a1}.q_{b1} \\\\\n", "q_{a1}.q_{b2} \\\\\n", "q_{a2}.q_{b1} \\\\\n", "q_{a2}.q_{b2}\n", "\\end{pmatrix}\n", "$$\n", "\n", " \n", "\n", "Using the tensor product, we can determine the vector of an $n$-qubit basis state. For example:\n", "\n", " \n", "\n", "$$|10\\rangle = |1\\rangle \\otimes |0\\rangle = \n", "\\begin{pmatrix}\n", "0 \\\\ \n", "1\n", "\\end{pmatrix} \\otimes\n", "\\begin{pmatrix}\n", "1 \\\\ \n", "0\n", "\\end{pmatrix} = \n", "\\begin{pmatrix}\n", "0 \\\\ \n", "0 \\\\\n", "1 \\\\\n", "0\n", "\\end{pmatrix}\n", "$$\n", "
\n", "\n", " \n", "\n", "### Entanglement and Bloch sphere for multi-qubit states\n", "\n", " \n", "\n", "Since qubits can be entangled, multi-qubit states, in general, cannot be expressed by simply representing each qubit's Bloch sphere. This is because the dimension of the vector space rises exponentially with the number of qubits, to account for correlation between qubits. One attempt to visualize multi-qubit states is made [here](https://medium.com/qiskit/visualizing-bits-and-qubits-9af287047b28). \n", "\n", "**For a quantum system, its description is more than the sum of descriptions for each individual qubit.**" ] }, { "cell_type": "markdown", "id": "ee9bfe27", "metadata": {}, "source": [ " \n", "\n", "## 3.1 Multi-qubit operations\n", "\n", " \n", "\n", "### CNOT gate \n", "\n", "The controlled-NOT (or controlled-$X$) gate allows for the creation of entanglement between two qubits in a quantum circuit. The CNOT gate's action on basis states is to flip, i.e. apply an $X$ gate to, the target qubit (denoted as $\\oplus$ in quantum circuits) if the control qubit (denoted as $\\bullet$), is $|1\\rangle$; otherwise the target qubit goes unchanged.\n", "\n", "The matrix describing a CNOT depends on which qubit acts as control. For a state $|q_1 q_0\\rangle$, if we apply a CNOT operation with $q_1$ as control, the matrix is described as:\n", "\n", "$$\n", "C_X = \n", "\\begin{pmatrix}\n", "1 & 0 & 0 & 0\\\\\n", "0 & 1 & 0 & 0\\\\\n", "0 & 0 & 0 & 1\\\\\n", "0 & 0 & 1 & 0\n", "\\end{pmatrix}. \n", "$$\n", "\n", "However, if $q_0$ is the control qubit, the gate is described by the following matrix:\n", "\n", "$$\n", "C_X = \n", "\\begin{pmatrix}\n", "1 & 0 & 0 & 0\\\\\n", "0 & 0 & 0 & 1\\\\\n", "0 & 0 & 1 & 0\\\\\n", "0 & 1 & 0 & 0\n", "\\end{pmatrix}. \n", "$$" ] }, { "cell_type": "code", "execution_count": null, "id": "6221c466", "metadata": {}, "outputs": [], "source": [ "# Create 2 registers and quantum circuit\n", "\n", "\n", "# Perform CNOT operation\n", "# The first argument is the control qubit, the second is the target\n", "\n", "# If we switch the arguments, the gate turns 'upside down'\n", "\n", "# Draw the circuit\n" ] }, { "cell_type": "markdown", "id": "ff307863", "metadata": {}, "source": [ "
\n", " \n", "Example 1.3 - Entangling two qubits \n", "\n", " \n", "\n", "Admit a 2-qubit quantum system, with $| q_0 \\rangle = \\frac{1}{\\sqrt{2}}(|0\\rangle + |1 \\rangle)$ and $|q_1\\rangle = | 0 \\rangle $. The initial two-qubit state can be written using the tensor product (i.e. a separable state):\n", "\n", "
\n", "$$\n", "|q_1 q_0 \\rangle = |0\\rangle \\otimes \\frac{1}{\\sqrt{2}} \\left ( |0\\rangle + |1\\rangle \\right ) = \\frac{1}{\\sqrt{2}}\\left ( |00\\rangle + |01\\rangle \\right )\n", "$$\n", "
\n", "\n", "Admit a CNOT gate $CX_{01}$ with qubit $q_0$ as control, and $q_1$ as target. The CNOT gate will map the two-qubit basis state $|01\\rangle$ to the state $|11\\rangle $, while leaving $|00\\rangle$ unchanged:\n", "\n", " \n", "\n", "
\n", "$$\n", "CX_{01} |q_1 q_0\\rangle = \\frac{1}{\\sqrt{2}}\\left ( |00\\rangle + |11\\rangle \\right )\n", "$$\n", "
\n", "\n", "The two-qubit state can not be described in terms of a tensor product of individual qubits - the qubits are **entangled**.\n", "\n", "
" ] }, { "cell_type": "markdown", "id": "836ee148", "metadata": {}, "source": [ "### Other multi-qubit operations\n", "\n", "The gate set presented so far allows for universal quantum computations, i.e. it is possible to decompose any quantum operations over $n$ qubits to arbitrary precision, using only this set of gates. How to efficiently determine and perform such a decomposition, however, is not a trivial problem.\n", " \n", "Other notable operators:\n", "\n", "- __SWAP gate__, which exchanges the state between two qubits:\n", "\n", " \n", "\n", "$$\n", "\\mathrm{SWAP} = \n", "\\begin{pmatrix}\n", "1 & 0 & 0 & 0\\\\\n", "0 & 0 & 1 & 0\\\\\n", "0 & 1 & 0 & 0\\\\\n", "0 & 0 & 0 & 1\n", "\\end{pmatrix}.\n", "$$\n", "\n", " \n", "\n", "- __Toffoli gate__ (or **CCNOT**), which performs a NOT operations on a target qubit, using two other qubits as controls." ] }, { "cell_type": "code", "execution_count": null, "id": "01739a3a", "metadata": {}, "outputs": [], "source": [ "# Create registers and quantum circuit\n", "\n", "# Apply Toffoli - first two arguments are the controls\n", "\n", "# Swap two qubits\n", "\n", "# Draw the circuit\n" ] }, { "cell_type": "markdown", "id": "e3ecf40f", "metadata": {}, "source": [ "
\n", "\n", "You can view a more extensive list of quantum operations in [Qiskit's online tutorials](https://qiskit.org/documentation/tutorials/circuits/3_summary_of_quantum_operations.html).\n", "\n", "
" ] }, { "cell_type": "markdown", "id": "bfaeed2a", "metadata": {}, "source": [ "
\n", "\n", "**Exercise 1.3 - Swap and CNOT equivalence**\n", "\n", " \n", "\n", "\"\" \n", " \n", " a) b)\n", "\n", " \n", "\n", "Consider the circuits depicted in the image above.\n", "\n", "1. Verify that operations **a)** and **b)** are equivalent, by building each into a quantum circuit, and comparing the unitary matrices with the `unitary_simulator`.\n", "\n", "1. In a new circuit, prepare the state $|q_1 q_0\\rangle = |+\\rangle|0\\rangle$. With the `statevector_simulator`, check the vector representation of the circuit, after preparing the initial state, and again after applying operation **b)**. Did the qubits swap states?\n", "\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": 18, "id": "72623799", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Unitary matrix:\n", "Operator([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n", " [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],\n", " [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],\n", " [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]],\n", " input_dims=(2, 2), output_dims=(2, 2))\n" ] } ], "source": [ "# Circuit a)\n", "from qiskit import Aer\n", "u_simulator = Aer.get_backend(\"unitary_simulator\")\n", "\n", "# Create registers and quantum circuit\n", "qr = QuantumRegister(2)\n", "qc_a = QuantumCircuit(qr)\n", "# Swap two qubits\n", "qc_a.swap(qr[0],qr[1])\n", "\n", "# Execute the circuit\n", "job_a = execute(qc_a, u_simulator, shots= 1000)\n", "state_a = job_a.result().get_unitary(qc_a, decimals= 3)\n", "\n", "# Print vector as a column\n", "print(\"Unitary matrix:\")\n", "print(state_a)\n", "\n", "#for i in uni_swap:\n", "# print(i.real)" ] }, { "cell_type": "code", "execution_count": 21, "id": "0148c93f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Unitary matrix:\n", "[1. 0. 0. 0.]\n", "[0. 0. 1. 0.]\n", "[0. 1. 0. 0.]\n", "[0. 0. 0. 1.]\n" ] } ], "source": [ "# Circuit b)\n", "\n", "# Create registers and quantum circuit\n", "n=2\n", "qr= QuantumRegister(n)\n", "\n", "circuitB = QuantumCircuit(qr)\n", "\n", "# 3 CNOT\n", "circuitB.cnot(qr[0], qr[1])\n", "circuitB.cnot(qr[1], qr[0])\n", "circuitB.cnot(qr[0], qr[1])\n", "\n", "# Execute the circuit\n", "u_simulator= BasicAer.get_backend('unitary_simulator')\n", "\n", "job_CB=execute(circuitB, u_simulator, shots=1000)\n", "\n", "# Get the resulting state vector\n", "state_CB= job_CB.result().get_unitary(circuitB, decimals=3)\n", "\n", "# Print vector as a column\n", "print(\"Unitary matrix:\")\n", "\n", "for i in state_CB:\n", " print(i.real)" ] }, { "cell_type": "code", "execution_count": 27, "id": "4c62039e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0.707+0.j 0. +0.j 0.707+0.j 0. +0.j]\n", "[0.707+0.j 0.707+0.j 0. +0.j 0. +0.j]\n" ] } ], "source": [ "# Question 2\n", "v_simulator=BasicAer.get_backend('statevector_simulator')\n", "# Create registers and quantum circuit\n", "qr=QuantumRegister(2)\n", "qc_c=QuantumCircuit(qr)\n", "# Prepare states\n", "qc_c.h(qr[1])\n", "# Check statevector\n", "job_a=execute(qc_c,v_simulator,shots=1000)\n", "state_a=job_a.result().get_statevector(qc_c,decimals=3)\n", "# Get the resulting state vector\n", "print(state_a)\n", "\n", "qc_c.swap(qr[0],qr[1])\n", "\n", "job_a=execute(qc_c,v_simulator,shots=1000)\n", "state_a=job_a.result().get_statevector(qc_c,decimals=3)\n", "# Get the resulting state vector\n", "print(state_a)\n", "# Print vector as a column\n", "#print(\"Statevector:\")\n", "\n", "#for i in uni_swap2:\n", "# print(i)" ] }, { "cell_type": "code", "execution_count": 29, "id": "a4234b91", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0.707+0.j 0. +0.j 0.707+0.j 0. +0.j]\n", "[0.707+0.j 0.707+0.j 0. +0.j 0. +0.j]\n" ] } ], "source": [ "# Now add operations\n", "\n", "# 3 CNOT\n", "\n", "# Check statevector again\n", "\n", "# Get the resulting state vector\n", "\n", "# Print vector as a column\n", "\n", "#for i in uni_swap2:\n", "# print(i)\n", "\n", "\n", "qr=QuantumRegister(2)\n", "qc_c=QuantumCircuit(qr)\n", "# Prepare states\n", "qc_c.h(qr[0])\n", "qc_c.cx(qr[1],qr[0])\n", "qc_c.cx(qr[0],qr[1])\n", "qc_c.cx(qr[1],qr[0])\n", "\n", "# Check statevector\n", "job_a=execute(qc_c,v_simulator,shots=1000)\n", "state_a=job_a.result().get_statevector(qc_c,decimals=3)\n", "# Get the resulting state vector\n", "print(state_a)\n", "\n", "qc_c.swap(qr[0],qr[1])\n", "\n", "job_a=execute(qc_c,v_simulator,shots=1000)\n", "state_a=job_a.result().get_statevector(qc_c,decimals=3)\n", "# Get the resulting state vector\n", "print(state_a)" ] }, { "cell_type": "markdown", "id": "baafcfb1", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "id": "3e4eb349", "metadata": {}, "source": [ "### Summary of Gates" ] }, { "cell_type": "markdown", "id": "a7380104", "metadata": {}, "source": [ "Gates implemented in Qiskit devices:\n", "\n", "$$u3(\\theta,\\phi,\\lambda) = \\begin{bmatrix}\\cos(\\theta /\\ 2) & -e^{i \\lambda }\\sin(\\theta /\\ 2) \\\\ e^{i\\phi}\\sin(\\theta /\\ 2) & e^{i\\lambda+i\\phi}\\cos(\\theta/\\ 2) \\end{bmatrix}$$\n", "\n", "$$u2(\\phi,\\lambda) = u3(\\pi /\\ 2,\\phi,\\lambda) = \\begin{bmatrix}1 & -e^{i \\lambda}\\\\ e^{i\\phi}& e^{i(\\lambda+\\phi)} \\end{bmatrix}$$\n", "\n", "$$u1(\\lambda) = u3(0,0,\\lambda) = \\begin{bmatrix}1 & 0\\\\ 0& e^{i\\lambda} \\end{bmatrix}$$\n", "\n", "$$u0(\\delta) = u3(0,0,0) = \\begin{bmatrix}1 & 0\\\\ 0&1 \\end{bmatrix}$$" ] }, { "cell_type": "markdown", "id": "daf13852", "metadata": {}, "source": [ "Some gates you can use:\n", "\n", "(Let qr being the quantum register and qc being the quantum circuit.)\n", "\n", "\n", "|Gate Name|Syntax |Matrix|How is it implemented| \n", "|-|-|-|-|\n", "|Identity |qc.id(qr)| $Id = \\begin{bmatrix} 1&0\\\\0&1 \\end{bmatrix}$|$u0(1)$|\n", "|Bit-flip or Pauli-X| qc.x(qr)| $ X = \\begin{bmatrix} 0&1\\\\1&0 \\end{bmatrix}$|$u3(\\pi,0,\\pi)$|\n", "|Bit and phase-flip or Pauli-Y| qc.y(qr)|$ Y = \\begin{bmatrix} 0&-i\\\\i&0 \\end{bmatrix}$|$u3(\\pi,\\pi /\\ 2,\\pi /\\ 2)$|\n", "|Phase-flip or Pauli-Z| qc.z(qr)| $Z = \\begin{bmatrix} 1&0\\\\0&-1 \\end{bmatrix}$|$u1(\\pi)$|\n", "|Hadamard|qc.h(qr)| $ H =\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 & 1 \\\\ 1 & -1\\end{bmatrix}$|$u2(0,\\pi)$|\n", "|S or $\\sqrt{Z}$-Phase|qc.s(qr)|$ S =\\begin{bmatrix} 1 & 0 \\\\ 0 & i\\end{bmatrix}$|$u1(\\pi /\\ 2)$|\n", "|S$^\\dagger$ or conjugate $\\sqrt{Z}$-Phase|qc.sdg(qr)| $S^\\dagger =\\begin{bmatrix} 1 & 0 \\\\ 0 & -i\\end{bmatrix}$|$u1(-\\pi /\\ 2)$|\n", "|T or $\\sqrt{S}$-Phase|qc.t(qr)| $T=\\begin{bmatrix}1 & 0 \\\\ 0 & e^{i \\pi /\\ 4}\\end{bmatrix}$| $u1( \\pi /\\ 4)$|\n", "|T$^\\dagger$ or conjugate $\\sqrt{S}$-Phase|qc.tdg(qr)| $ T^\\dagger =\\begin{bmatrix}1 & 0 \\\\ 0 & e^{-i \\pi /\\ 4}\\end{bmatrix}$| $u1( -\\pi /\\ 4)$|\n", "\n" ] }, { "cell_type": "markdown", "id": "a13cfcb4", "metadata": {}, "source": [ "Multiqubit gates:\n", "\n", "The matrix looks different from the rest of the bibliography because qiskit uses different definitions of least and most significant qubits.\n", "\n", "Let control be the the 0 qubit and the target the 1 qubit.\n", "\n", "|Gate Name|Syntax |Matrix| \n", "|-|-|-|\n", "|Controlled-X or controlled-Not|qc.cx(qr\\[control\\],qr\\[target\\])|$CX = \\begin{bmatrix}1&0&0&0\\\\0&0&0&1\\\\0&0&1&0\\\\0&1&0&0\\end{bmatrix}$ |\n", "|Controlled-Y|qc.cy(qr\\[control\\],qr\\[target\\])|$CY = \\begin{bmatrix}1&0&0&0\\\\0&0&0&-i\\\\0&0&1&0\\\\0&i&0&0\\end{bmatrix}$ |\n", "|Controlled-Z or controlled-Phase|qc.cz(qr\\[control\\],qr\\[target\\])| $CZ =\\begin{bmatrix}1&0&0&0\\\\0&1&0&0\\\\0&0&1&0\\\\0&0&0&-1\\end{bmatrix}$ |\n", "|Controlled-Hadamard|qc.ch(qr\\[control\\],qr\\[target\\])|$CH = \\begin{bmatrix}1&0&0&0\\\\0&\\frac{1}{\\sqrt{2}}&0&\\frac{1}{\\sqrt{2}}\\\\0&0&1&0\\\\0&\\frac{1}{\\sqrt{2}}&0&-\\frac{1}{\\sqrt{2}}\\end{bmatrix}$ |\n", "|SWAP|qc.swap(qr\\[control\\],qr\\[target\\])| $SAWP =\\begin{bmatrix}1&0&0&0\\\\0&0&1&0\\\\0&1&0&0\\\\0&0&0&1\\end{bmatrix}$ |" ] }, { "cell_type": "markdown", "id": "e0704c4c", "metadata": {}, "source": [ "Finally, there is the measure gate.\n", "\n", "* qc.measure(qr,cr) - it adds measures to all qubits\n", "* qc.measure_all() - it adds measure to all qubits and creates the classical space to register the measures\n", "* qc.measure(qr\\[0\\],cr\\[0\\]) - it adds a measure to qubit 0 and saves value in classical register 0" ] }, { "cell_type": "code", "execution_count": null, "id": "c1847c08", "metadata": {}, "outputs": [], "source": [ "import qiskit.tools.jupyter\n", "%qiskit_version_table" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.4" } }, "nbformat": 4, "nbformat_minor": 5 }